﻿using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using DynamicAuditor.DTOs;

namespace DynamicAuditor.DALAuditor
{

    /// <summary>
    /// Fecha: 12-Noviembre-2010
    /// Autor:Kenneth Bogantes F
    /// Descripcion: En esta clase se va a manejar todas las operaciones correspondientes a SUB PROCESOS COBIT tales como: Insercion, Actualizacion, Eliminacion
    /// y todo lo relaciona con SUB PROCESOS COBIT.
    /// </summary>

   public class clsSubProcesoCobitMg
   {

       #region conexion

       //Declaracion de la varaiable tipo datacontext que vamos a utilizar en toda la clase.
       DynamicAuditorDataContext bd = new DynamicAuditorDataContext();

       #endregion 

       #region Funciones_Basicas_Mantenimientos

       //--------------------------------------------------------------------------------------------------------------------------

       public int InsertSubProcesoCobit(DTOs.dtoSubProcesoCobit SubProcesoCobit)
       {
           //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

           int x = 0;
           SUBPROCESOS_COBIT nuevoRegistro = new SUBPROCESOS_COBIT();

           try
           {
               

               nuevoRegistro.idProceso = SubProcesoCobit.ProcesoCobit.Idproceso;             
               nuevoRegistro.Descripcion = SubProcesoCobit.Descripcion;
               nuevoRegistro.NombreSubProceso = SubProcesoCobit.NombreSubProceso;
               nuevoRegistro.SiglaSubProceso = SubProcesoCobit.SiglasSubProceso;
               nuevoRegistro.Activo = SubProcesoCobit.Activo;
               
               //Se procede a insertar la informacion del proceso cobit
               bd.SUBPROCESOS_COBITs.InsertOnSubmit(nuevoRegistro);
               bd.SubmitChanges();
               x = 1;
           }
           catch (Exception ex)
           {
               throw new Exception("No se pudo insertar el registro. " + ex.Message);

           }
           return x;
       }



       //--------------------------------------------------------------------------------------------------------------------------


       public int UpdateSubProcesoCobit(DTOs.dtoSubProcesoCobit SubProcesoCobit)
       {
           //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

           int x = 0;


           try
           {

                SUBPROCESOS_COBIT registro = bd.SUBPROCESOS_COBITs.Single(p => p.idSubProceso == SubProcesoCobit.IdSubProceso);

                registro.idProceso = int.Parse ( SubProcesoCobit.ProcesoCobit.Idproceso.ToString ());
                registro.idSubProceso = SubProcesoCobit.IdSubProceso;
                registro.NombreSubProceso = SubProcesoCobit.NombreSubProceso;
                registro.SiglaSubProceso = SubProcesoCobit.SiglasSubProceso;
                registro.Descripcion = SubProcesoCobit.Descripcion;
                registro.Activo = bool.Parse ( SubProcesoCobit.Activo.ToString());

            
               bd.SubmitChanges();
               x = 1;
           }
           catch (Exception ex)
           {
               throw new Exception("Ocurrio un error actualizando el registro. " + ex.Message);
           }
           return x;
       }



       //--------------------------------------------------------------------------------------------------------------------------



       public int DeleteSubProcesoCobit(DTOs.dtoSubProcesoCobit SubProcesoCobit)
       {
           //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

           int x = 0;

           try
           {

               var registro = bd.SUBPROCESOS_COBITs.Single(p => p.idSubProceso == SubProcesoCobit.IdSubProceso);

               bd.SUBPROCESOS_COBITs.DeleteOnSubmit(registro);
               bd.SubmitChanges();
               x = 1;
           }
           catch (Exception ex)
           {
               throw new Exception("No se pudo borrar el registro " + ex.Message);
              
           }

           return x;

       }


       //--------------------------------------------------------------------------------------------------------------------------



       public DTOs.dtoSubProcesoCobit ObtenerSubProcesoCobitporId(int idSubProcesoCobit)
       {
           DTOs.dtoSubProcesoCobit registro = new DynamicAuditor.DTOs.dtoSubProcesoCobit();

           try
           {
                SUBPROCESOS_COBIT dato = bd.SUBPROCESOS_COBITs.Single(p => p.idSubProceso == idSubProcesoCobit);

                registro.IdSubProceso = idSubProcesoCobit;
                registro.ProcesoCobit = new clsProcesoCobitMg().ObtenerProcesoCobitporId(int.Parse(dato.idProceso.ToString()));
                registro.NombreSubProceso = dato.NombreSubProceso;
                registro.SiglasSubProceso = dato.SiglaSubProceso;
                registro.Descripcion = dato.Descripcion;
                registro.Activo = bool.Parse( dato.Activo.ToString());

            
           }
           catch (Exception ex)
           {

               throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
               return null; 
           }

           return registro;
       }



       //--------------------------------------------------------------------------------------------------------------------------



       public DTOs.dtoSubProcesoCobit ObtenerSubProcesoCobitporSiglas(string siglas)
       {
           DTOs.dtoSubProcesoCobit registro = new DynamicAuditor.DTOs.dtoSubProcesoCobit();

           try
           {
               SUBPROCESOS_COBIT dato = bd.SUBPROCESOS_COBITs.Single(p => p.SiglaSubProceso == siglas.Trim());

               registro.IdSubProceso = int.Parse(dato.idSubProceso.ToString());
               registro.ProcesoCobit = new clsProcesoCobitMg().ObtenerProcesoCobitporId(int.Parse(dato.idProceso.ToString()));

               registro.NombreSubProceso = dato.NombreSubProceso;
               registro.SiglasSubProceso = dato.SiglaSubProceso;
               registro.Descripcion = dato.Descripcion;
               registro.Activo = bool.Parse(dato.Activo.ToString());


           }
           catch (Exception ex)
           {

               throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
               return null;
           }

           return registro;
       }


       //--------------------------------------------------------------------------------------------------------------------------




       //--------------------------------------------------------------------------------------------------------------------------



       public List<DTOs.dtoSubProcesoCobit> ObtenerSubProcesosCobit(int idprocesocobit)
       {
           int i = 0;
           List<DTOs.dtoSubProcesoCobit> listaDatos = new List<DTOs.dtoSubProcesoCobit>();

           try
           {
               var datos = (from p in bd.SUBPROCESOS_COBITs
                            from d in bd.PROCESOS_COBITs
                            where p.idProceso == d.idProceso && p.idProceso ==idprocesocobit
                            orderby p.idSubProceso
                            select new { p, d }

                          );

               foreach (var fila  in datos)
               {
                   listaDatos.Add(new dtoSubProcesoCobit());

                   listaDatos[i].IdSubProceso = fila.p.idSubProceso;
                   listaDatos[i].ProcesoCobit = toDTOProcesoCobit(fila.d);
                   listaDatos[i].NombreSubProceso = fila.p.NombreSubProceso ;
                   listaDatos[i].Descripcion = fila.p.Descripcion ;
                   listaDatos[i].SiglasSubProceso = fila.p.SiglaSubProceso;

                   listaDatos[i].Activo = (bool) fila.p.Activo;
                   i++;
               }

           }
           catch (Exception ex)
           {
               throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
           }
           return listaDatos;
       }


       //--------------------------------------------------------------------------------------------------------------------------




       public List<DTOs.dtoSubProcesoCobit> ObtenerSubProcesosCobitActivos(int idprocesocobit)
       {
           int i = 0;
           List<DTOs.dtoSubProcesoCobit> listaDatos = new List<DTOs.dtoSubProcesoCobit>();

           try
           {
               var datos = (from p in bd.SUBPROCESOS_COBITs
                            from d in bd.PROCESOS_COBITs
                            where p.idProceso == d.idProceso && p.idProceso == idprocesocobit && p.Activo == true
                            orderby p.idSubProceso
                            select new { p, d }

                          );

               foreach (var fila in datos)
               {
                   listaDatos.Add(new dtoSubProcesoCobit());

                   listaDatos[i].IdSubProceso = fila.p.idSubProceso;
                   listaDatos[i].ProcesoCobit = toDTOProcesoCobit(fila.d);
                   listaDatos[i].NombreSubProceso = fila.p.NombreSubProceso;
                   listaDatos[i].Descripcion = fila.p.Descripcion;
                   listaDatos[i].SiglasSubProceso = fila.p.SiglaSubProceso;

                   listaDatos[i].Activo = (bool)fila.p.Activo;
                   i++;
               }

           }
           catch (Exception ex)
           {
               throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
           }
           return listaDatos;
       }


       //--------------------------------------------------------------------------------------------------------------------------



       public dtoProcesoCobit toDTOProcesoCobit(PROCESOS_COBIT procesoCobit) {
           dtoProcesoCobit nuevo = new dtoProcesoCobit();
           nuevo.Idproceso = procesoCobit.idProceso;
           nuevo.Nombreproceso = procesoCobit.NombreProceso;
           nuevo.Dominio = new dtoDominios();
           nuevo.Siglasproceso = procesoCobit.SiglaProceso;
           nuevo.Descripcion = procesoCobit.Descripcion;
           nuevo.Activo = (bool)procesoCobit.Activo;
           return nuevo;
       }







       #endregion





   }
}
